BZip2CompressorOutputStream.java

        nInUse = 0;

        for (i = 0; i < 256; i++) {

            if (inUse[i]) {

                seqToUnseq[nInUse] = (char) i;

                unseqToSeq[i] = (char) nInUse;

                nInUse++;

    }

        int[] heap = new int[MAX_ALPHA_SIZE + 2];

        int[] weight = new int[MAX_ALPHA_SIZE * 2];

        int[] parent = new int[MAX_ALPHA_SIZE * 2];

        for (i = 0; i < alphaSize; i++) {

            weight[i + 1] = (freq[i] == 0 ? 1 : freq[i]) << 8;

            nNodes = alphaSize;

            nHeap = 0;

            heap[0] = 0;

            weight[0] = 0;

            parent[0] = -2;

            for (i = 1; i <= alphaSize; i++) {

                parent[i] = -1;

                nHeap++;

                heap[nHeap] = i;

                    zz = nHeap;

                    tmp = heap[zz];

                    while (weight[tmp] < weight[heap[zz >> 1]]) {

                        heap[zz] = heap[zz >> 1];

                        zz >>= 1;

                    heap[zz] = tmp;

            if (!(nHeap < (MAX_ALPHA_SIZE + 2))) {

            while (nHeap > 1) {

                n1 = heap[1];

                heap[1] = heap[nHeap];

                nHeap--;

                    int zz = 0, yy = 0, tmp = 0;

                    zz = 1;

                    tmp = heap[zz];

                        yy = zz << 1;

                        if (yy > nHeap) {

                            break;

                        if (yy < nHeap

                            yy++;

                        if (weight[tmp] < weight[heap[yy]]) {

                            break;

                        heap[zz] = heap[yy];

                        zz = yy;

                    heap[zz] = tmp;

                n2 = heap[1];

                heap[1] = heap[nHeap];

                nHeap--;

                    int zz = 0, yy = 0, tmp = 0;

                    zz = 1;

                    tmp = heap[zz];

                        yy = zz << 1;

                        if (yy > nHeap) {

                            break;

                        if (yy < nHeap

                        if (weight[tmp] < weight[heap[yy]]) {

                            break;

                        heap[zz] = heap[yy];

                        zz = yy;

                    heap[zz] = tmp;

                nNodes++;

                parent[n1] = parent[n2] = nNodes;

                weight[nNodes] = ((weight[n1] & 0xffffff00)

                    | (1 + (((weight[n1] & 0x000000ff)

                            ? (weight[n1] & 0x000000ff)

                            : (weight[n2] & 0x000000ff)));

                parent[nNodes] = -1;

                nHeap++;

                heap[nHeap] = nNodes;

                    int zz = 0, tmp = 0;

                    zz = nHeap;

                    tmp = heap[zz];

                    while (weight[tmp] < weight[heap[zz >> 1]]) {

                        heap[zz] = heap[zz >> 1];

                        zz >>= 1;

                    heap[zz] = tmp;

                }

            if (!(nNodes < (MAX_ALPHA_SIZE * 2))) {

            tooLong = false;

            for (i = 1; i <= alphaSize; i++) {

                j = 0;

                k = i;

                while (parent[k] >= 0) {

                    k = parent[k];

                    j++;

                len[i - 1] = (char) j;

                if (j > maxLen) {

            if (!tooLong) {

                break;

    }

    private final CRC mCrc = new CRC();

    private boolean[] inUse = new boolean[256];

    private char[] seqToUnseq = new char[256];

    private char[] unseqToSeq = new char[256];

    private char[] selector = new char[MAX_SELECTORS];

    private char[] selectorMtf = new char[MAX_SELECTORS];

    private int[] mtfFreq = new int[MAX_ALPHA_SIZE];

    private int currentChar = -1;

    private int runLength = 0;

        this(inStream, 9);

    }

        throws IOException {

        block = null;

        quadrant = null;

        zptr = null;

        ftab = null;

        bsSetStream(inStream);

        workFactor = 50;

        if (inBlockSize > 9) {

        if (inBlockSize < 1) {

        blockSize100k = inBlockSize;

        allocateCompressStructures();

        initialize();

        initBlock();

    }

        int b = (256 + bv) % 256;

        if (currentChar != -1) {

            if (currentChar == b) {

                runLength++;

                if (runLength > 254) {

                writeRun();

                runLength = 1;

                currentChar = b;

            currentChar = b;

            runLength++;

    }

        if (last < allowableBlockSize) {

            inUse[currentChar] = true;

            for (int i = 0; i < runLength; i++) {

                mCrc.updateCRC((char) currentChar);

            switch (runLength) {

                last++;

                block[last + 1] = (char) currentChar;

                break;

                last++;

                block[last + 1] = (char) currentChar;

                last++;

                block[last + 1] = (char) currentChar;

                break;

                last++;

                block[last + 1] = (char) currentChar;

                last++;

                block[last + 1] = (char) currentChar;

                last++;

                block[last + 1] = (char) currentChar;

                break;

                inUse[runLength - 4] = true;

                last++;

                block[last + 1] = (char) currentChar;

                last++;

                block[last + 1] = (char) currentChar;

                last++;

                block[last + 1] = (char) currentChar;

                last++;

                block[last + 1] = (char) currentChar;

                last++;

                block[last + 1] = (char) (runLength - 4);

                break;

    }

    private boolean closed = false;

        if (closed) {

        finish();

        super.close();

        bsStream.close();

        closed = true;

    }

        if (closed) {

        if (runLength > 0) {

            writeRun();

        currentChar = -1;

        endBlock();

        endCompression();

    }

        bytesOut = 0;

        nBlocksRandomised = 0;

        bsPutUChar('B');

        bsPutUChar('Z');

        bsPutUChar('h');

        bsPutUChar('0' + blockSize100k);

        combinedCRC = 0;

    }

        mCrc.initialiseCRC();

        last = -1;

        for (int i = 0; i < 256; i++) {

            inUse[i] = false;

        allowableBlockSize = baseBlockSize * blockSize100k - 20;

    }

        blockCRC = mCrc.getFinalCRC();

        combinedCRC = (combinedCRC << 1) | (combinedCRC >>> 31);

        combinedCRC ^= blockCRC;

        if (last == -1) {

        doReversibleTransformation();

        bsPutUChar(0x31);

        bsPutUChar(0x41);

        bsPutUChar(0x59);

        bsPutUChar(0x26);

        bsPutUChar(0x53);

        bsPutUChar(0x59);

        bsPutint(blockCRC);

        if (blockRandomised) {

            bsW(1, 0);

        moveToFrontCodeAndSend();

    }

        bsPutUChar(0x17);

        bsPutUChar(0x72);

        bsPutUChar(0x45);

        bsPutUChar(0x38);

        bsPutUChar(0x50);

        bsPutUChar(0x90);

        bsPutint(combinedCRC);

        bsFinishedWithStream();

    }

        vec = 0;

        for (n = minLen; n <= maxLen; n++) {

            for (i = 0; i < alphaSize; i++) {

                if (length[i] == n) {

                    code[i] = vec;

                    vec++;